<html>
    <head>
        <!--[if IE]><script language="javascript" type="text/javascript" src="./excanvas.min.js"></script><![endif]-->
        <script language="javascript" type="text/javascript" src="./jquery.js"></script>
        <script language="javascript" type="text/javascript" src="./jquery.flot.js"></script>
    </head>
    <body>

<script>
    $("<div id='tooltip'></div>").css({
                                    position: "absolute",
                                    display: "none",
                                    border: "1px solid #fdd",
                                    padding: "2px",
                                    "background-color": "#fee",
                                    opacity: 0.80
                                  }).appendTo("body");
                
    series_settings = {
        lines: { show: true },
        points: { show: true }
    };

    grid_settings = { tickColor: '#ddd', hoverable: true };

    xaxis_settings = {
        tickFormatter: function(num, obj) { 
                           if(num >= 1000*1000) {
                               return parseFloat(num/(1000*1000)).toFixed(2) + 'M'; 
                           }
                           else {
                               return parseInt(num/1000) + 'k'; 
                           }
                       }
    };

    yaxis_runtime_settings = {
        tickFormatter: function(num, obj) { return (+num.toFixed(2)) + ' sec.'; }
    };

    yaxis_memory_settings = {
        tickFormatter: function(num, obj) { return parseInt(num/1024/1024) + 'MiB'; }
    };

    legend_settings = {
        position: 'nw',
        backgroundOpacity: 0
    };

    runtime_settings = {
        series: series_settings,
        grid: grid_settings,
        xaxis: xaxis_settings,
        yaxis: yaxis_runtime_settings,
        legend: legend_settings
    };

    memory_settings = {
        series: series_settings,
        grid: grid_settings,
        xaxis: xaxis_settings,
        yaxis: yaxis_memory_settings,
        legend: legend_settings
    };

    chart_data = {"read_random_full_after_delete_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.118157, 0.47], [2000000, 0.265822, 0.47], [3000000, 0.373502, 0.34], [4000000, 0.568769, 0.46], [5000000, 0.631033, 0.28], [6000000, 0.841182, 0.34], [7000000, 1.03369, 0.4], [8000000, 1.16575, 0.45], [9000000, 1.14827, 0.25], [10000000, 1.30486, 0.28]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.027204, 0.24], [2000000, 0.067559, 0.24], [3000000, 0.091752, 0.36], [4000000, 0.136906, 0.24], [5000000, 0.175606, 0.3], [6000000, 0.217767, 0.36], [7000000, 0.325811, 0.42], [8000000, 0.334789, 0.24], [9000000, 0.381702, 0.27], [10000000, 0.425207, 0.3]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.037164, 0.24], [2000000, 0.080618, 0.24], [3000000, 0.129824, 0.36], [4000000, 0.194078, 0.24], [5000000, 0.245082, 0.3], [6000000, 0.382435, 0.36], [7000000, 0.402464, 0.42], [8000000, 0.537295, 0.24], [9000000, 0.596612, 0.27], [10000000, 0.617469, 0.3]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.024022, 0.24], [2000000, 0.051004, 0.24], [3000000, 0.084259, 0.36], [4000000, 0.105128, 0.24], [5000000, 0.139956, 0.3], [6000000, 0.242817, 0.36], [7000000, 0.290429, 0.42], [8000000, 0.298351, 0.24], [9000000, 0.317904, 0.27], [10000000, 0.373247, 0.3]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.039733, 0.24], [2000000, 0.074077, 0.24], [3000000, 0.118076, 0.36], [4000000, 0.152232, 0.24], [5000000, 0.231759, 0.3], [6000000, 0.246692, 0.36], [7000000, 0.321758, 0.21], [8000000, 0.357815, 0.24], [9000000, 0.430893, 0.27], [10000000, 0.463455, 0.3]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.026078, 0.24], [2000000, 0.055059, 0.24], [3000000, 0.088166, 0.36], [4000000, 0.114964, 0.24], [5000000, 0.147185, 0.3], [6000000, 0.184716, 0.36], [7000000, 0.288318, 0.42], [8000000, 0.340394, 0.24], [9000000, 0.334102, 0.27], [10000000, 0.37815, 0.3]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.02905, 0.24], [2000000, 0.060883, 0.24], [3000000, 0.096704, 0.36], [4000000, 0.166245, 0.24], [5000000, 0.158371, 0.3], [6000000, 0.196336, 0.36], [7000000, 0.309134, 0.42], [8000000, 0.332614, 0.24], [9000000, 0.396116, 0.27], [10000000, 0.41328, 0.3]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.026603, 0.24], [2000000, 0.069547, 0.24], [3000000, 0.090761, 0.36], [4000000, 0.153907, 0.24], [5000000, 0.148463, 0.3], [6000000, 0.276065, 0.36], [7000000, 0.291703, 0.42], [8000000, 0.336257, 0.24], [9000000, 0.365868, 0.27], [10000000, 0.384964, 0.3]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.055157, 0.48], [2000000, 0.107805, 0.48], [3000000, 0.182285, 0.36], [4000000, 0.226734, 0.48], [5000000, 0.265506, 0.3], [6000000, 0.331117, 0.36], [7000000, 0.426899, 0.42], [8000000, 0.504932, 0.48], [9000000, 0.574203, 0.27], [10000000, 0.617566, 0.3]], "label": "emhash4::HashMap"}], 
"insert_random_shuffle_range_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.178966, 0.95], [2000000, 0.447918, 0.93], [3000000, 0.874397, 0.69], [4000000, 1.1191, 0.92], [5000000, 1.66138, 0.57], [6000000, 1.95354, 0.68], [7000000, 2.14387, 0.79], [8000000, 2.30973, 0.9], [9000000, 3.1456, 0.5], [10000000, 3.96097, 0.56]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.114035, 0.48], [2000000, 0.244006, 0.48], [3000000, 0.308411, 0.72], [4000000, 0.457905, 0.48], [5000000, 0.629224, 0.6], [6000000, 0.652671, 0.72], [7000000, 0.74538, 0.83], [8000000, 1.17564, 0.48], [9000000, 1.14016, 0.54], [10000000, 1.2397, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.102825, 0.48], [2000000, 0.225228, 0.48], [3000000, 0.312579, 0.72], [4000000, 0.574995, 0.48], [5000000, 0.66786, 0.6], [6000000, 0.688742, 0.72], [7000000, 0.935053, 0.83], [8000000, 1.1249, 0.48], [9000000, 1.24376, 0.54], [10000000, 1.35743, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.11804, 0.48], [2000000, 0.25535, 0.48], [3000000, 16.2104, 0.72], [4000000, 0.636467, 0.48], [5000000, 29.9532, 0.6], [6000000, 22.942, 0.72], [7000000, 55.2802, 0.83], [8000000, 1.21158, 0.48], [9000000, 34.2818, 0.54], [10000000, 61.9789, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.147652, 0.48], [2000000, 0.26984, 0.48], [3000000, 0.411942, 0.72], [4000000, 0.590311, 0.48], [5000000, 0.666626, 0.6], [6000000, 0.861908, 0.72], [7000000, 0.817905, 0.83], [8000000, 1.30112, 0.48], [9000000, 1.38859, 0.54], [10000000, 1.53037, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.112214, 0.48], [2000000, 0.209192, 0.48], [3000000, 0.375957, 0.72], [4000000, 0.452726, 0.48], [5000000, 0.619455, 0.6], [6000000, 0.695147, 0.72], [7000000, 0.742382, 0.83], [8000000, 1.00817, 0.48], [9000000, 1.34461, 0.54], [10000000, 1.57369, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.093062, 0.48], [2000000, 0.206902, 0.48], [3000000, 1.8669, 0.72], [4000000, 0.463405, 0.48], [5000000, 1.65271, 0.6], [6000000, 6.07439, 0.72], [7000000, 5.03898, 0.83], [8000000, 1.01498, 0.48], [9000000, 1.4422, 0.54], [10000000, 4.73932, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.112329, 0.48], [2000000, 0.209369, 0.48], [3000000, 0.364243, 0.72], [4000000, 0.452156, 0.48], [5000000, 0.597453, 0.6], [6000000, 0.759843, 0.72], [7000000, 0.71135, 0.83], [8000000, 0.993029, 0.48], [9000000, 1.30388, 0.54], [10000000, 1.32248, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.088042, 0.95], [2000000, 0.204641, 0.95], [3000000, 0.39258, 0.72], [4000000, 0.524424, 0.95], [5000000, 0.751829, 0.6], [6000000, 0.834949, 0.72], [7000000, 0.913337, 0.83], [8000000, 0.990878, 0.95], [9000000, 1.4808, 0.54], [10000000, 1.69468, 0.6]], "label": "emhash4::HashMap"}], 
"read_random_shuffle_range_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.07816, 0.95], [2000000, 0.171901, 0.93], [3000000, 0.293304, 0.69], [4000000, 0.386406, 0.92], [5000000, 0.496974, 0.57], [6000000, 0.590564, 0.68], [7000000, 0.658388, 0.79], [8000000, 0.750528, 0.9], [9000000, 0.962841, 0.5], [10000000, 1.00703, 0.56]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.0214, 0.48], [2000000, 0.044822, 0.48], [3000000, 0.084722, 0.72], [4000000, 0.098035, 0.48], [5000000, 0.121003, 0.6], [6000000, 0.154683, 0.72], [7000000, 0.283763, 0.83], [8000000, 0.354858, 0.48], [9000000, 0.317576, 0.54], [10000000, 0.430769, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.028732, 0.48], [2000000, 0.066216, 0.48], [3000000, 0.122359, 0.72], [4000000, 0.197192, 0.48], [5000000, 0.19964, 0.6], [6000000, 0.23746, 0.72], [7000000, 0.344527, 0.83], [8000000, 0.491666, 0.48], [9000000, 0.491896, 0.54], [10000000, 0.516349, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.013423, 0.48], [2000000, 0.028541, 0.48], [3000000, 0.052961, 0.72], [4000000, 0.060088, 0.48], [5000000, 0.092772, 0.6], [6000000, 0.091244, 0.72], [7000000, 0.124779, 0.83], [8000000, 0.145087, 0.48], [9000000, 0.149378, 0.54], [10000000, 0.24304, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.015728, 0.48], [2000000, 0.031823, 0.48], [3000000, 0.050648, 0.72], [4000000, 0.063177, 0.48], [5000000, 0.11293, 0.6], [6000000, 0.100476, 0.72], [7000000, 0.190282, 0.83], [8000000, 0.193738, 0.48], [9000000, 0.237298, 0.54], [10000000, 0.214692, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.013464, 0.48], [2000000, 0.02854, 0.48], [3000000, 0.04376, 0.72], [4000000, 0.059378, 0.48], [5000000, 0.076336, 0.6], [6000000, 0.090807, 0.72], [7000000, 0.106289, 0.83], [8000000, 0.216847, 0.48], [9000000, 0.240314, 0.54], [10000000, 0.172608, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.013356, 0.48], [2000000, 0.028503, 0.48], [3000000, 0.054903, 0.72], [4000000, 0.060573, 0.48], [5000000, 0.075813, 0.6], [6000000, 0.090957, 0.72], [7000000, 0.106975, 0.83], [8000000, 0.145425, 0.48], [9000000, 0.16769, 0.54], [10000000, 0.162192, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.014289, 0.48], [2000000, 0.028359, 0.48], [3000000, 0.054142, 0.72], [4000000, 0.079702, 0.48], [5000000, 0.07526, 0.6], [6000000, 0.091051, 0.72], [7000000, 0.106879, 0.83], [8000000, 0.146123, 0.48], [9000000, 0.248055, 0.54], [10000000, 0.243562, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.01345, 0.95], [2000000, 0.028331, 0.95], [3000000, 0.044829, 0.72], [4000000, 0.075834, 0.95], [5000000, 0.076384, 0.6], [6000000, 0.128349, 0.72], [7000000, 0.160574, 0.83], [8000000, 0.135941, 0.95], [9000000, 0.170549, 0.54], [10000000, 0.172683, 0.6]], "label": "emhash4::HashMap"}], 
"insert_random_full_reserve_memory": [{"program": "std_unordered_map", "data": [[1000000, 40718336, 0.95], [2000000, 81149952, 0.93], [3000000, 121606144, 0.94], [4000000, 160157696, 0.99], [5000000, 200884224, 0.98], [6000000, 243703808, 0.93], [7000000, 284737536, 0.93], [8000000, 321691648, 0.98], [9000000, 364597248, 0.94], [10000000, 403251200, 0.97]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 36007936, 0.48], [2000000, 71356416, 0.48], [3000000, 71196672, 0.72], [4000000, 142798848, 0.48], [5000000, 142663680, 0.6], [6000000, 142766080, 0.72], [7000000, 142798848, 0.83], [8000000, 285540352, 0.48], [9000000, 285462528, 0.54], [10000000, 285716480, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 35770368, 0.48], [2000000, 71413760, 0.48], [3000000, 71413760, 0.72], [4000000, 142848000, 0.48], [5000000, 142761984, 0.6], [6000000, 142647296, 0.72], [7000000, 142786560, 0.83], [8000000, 285323264, 0.48], [9000000, 285413376, 0.54], [10000000, 285437952, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 50630656, 0.48], [2000000, 100716544, 0.48], [3000000, 100683776, 0.72], [4000000, 201580544, 0.48], [5000000, 201515008, 0.6], [6000000, 201310208, 0.72], [7000000, 201461760, 0.83], [8000000, 402755584, 0.48], [9000000, 402677760, 0.54], [10000000, 403095552, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 50618368, 0.48], [2000000, 100986880, 0.48], [3000000, 100745216, 0.72], [4000000, 201580544, 0.48], [5000000, 201453568, 0.6], [6000000, 201248768, 0.72], [7000000, 402808832, 0.42], [8000000, 402817024, 0.48], [9000000, 402747392, 0.54], [10000000, 403156992, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 50753536, 0.48], [2000000, 100765696, 0.48], [3000000, 100655104, 0.72], [4000000, 201641984, 0.48], [5000000, 201302016, 0.6], [6000000, 201515008, 0.72], [7000000, 201400320, 0.83], [8000000, 402710528, 0.48], [9000000, 402817024, 0.54], [10000000, 403156992, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 50753536, 0.48], [2000000, 100798464, 0.48], [3000000, 100716544, 0.72], [4000000, 201453568, 0.48], [5000000, 201424896, 0.6], [6000000, 201453568, 0.72], [7000000, 201347072, 0.83], [8000000, 402878464, 0.48], [9000000, 402808832, 0.54], [10000000, 403034112, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 50806784, 0.48], [2000000, 100716544, 0.48], [3000000, 100716544, 0.72], [4000000, 201392128, 0.48], [5000000, 201453568, 0.6], [6000000, 201453568, 0.72], [7000000, 201469952, 0.83], [8000000, 402878464, 0.48], [9000000, 402808832, 0.54], [10000000, 403095552, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 25513984, 0.95], [2000000, 50753536, 0.95], [3000000, 101347328, 0.72], [4000000, 101457920, 0.95], [5000000, 202534912, 0.6], [6000000, 202797056, 0.72], [7000000, 202481664, 0.83], [8000000, 202330112, 0.95], [9000000, 405041152, 0.54], [10000000, 404987904, 0.6]], "label": "emhash4::HashMap"}], 
"insert_random_full_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.295098, 0.95], [2000000, 0.723786, 0.93], [3000000, 1.22396, 0.69], [4000000, 1.54507, 0.92], [5000000, 2.39216, 0.57], [6000000, 2.69962, 0.68], [7000000, 3.02622, 0.79], [8000000, 3.68367, 0.9], [9000000, 5.36263, 0.5], [10000000, 5.22597, 0.56]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.129986, 0.48], [2000000, 0.279093, 0.48], [3000000, 0.367009, 0.72], [4000000, 0.704969, 0.48], [5000000, 0.690349, 0.6], [6000000, 0.927073, 0.72], [7000000, 1.12726, 0.83], [8000000, 1.53144, 0.48], [9000000, 1.69285, 0.54], [10000000, 1.60526, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.106046, 0.48], [2000000, 0.264434, 0.48], [3000000, 0.320761, 0.72], [4000000, 0.506987, 0.48], [5000000, 0.608877, 0.6], [6000000, 0.833789, 0.72], [7000000, 0.976343, 0.83], [8000000, 1.17138, 0.48], [9000000, 1.29127, 0.54], [10000000, 1.66212, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.166877, 0.48], [2000000, 0.410403, 0.48], [3000000, 0.532654, 0.72], [4000000, 0.887186, 0.48], [5000000, 0.879575, 0.6], [6000000, 0.994297, 0.72], [7000000, 1.23083, 0.83], [8000000, 1.87083, 0.48], [9000000, 1.98165, 0.54], [10000000, 1.9326, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.155328, 0.48], [2000000, 0.298983, 0.48], [3000000, 0.405436, 0.72], [4000000, 0.622923, 0.48], [5000000, 0.721012, 0.6], [6000000, 0.972423, 0.72], [7000000, 1.32, 0.42], [8000000, 1.52853, 0.48], [9000000, 1.68598, 0.54], [10000000, 1.65946, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.149487, 0.48], [2000000, 0.340211, 0.48], [3000000, 0.450937, 0.72], [4000000, 0.73378, 0.48], [5000000, 0.863569, 0.6], [6000000, 0.961625, 0.72], [7000000, 1.29519, 0.83], [8000000, 1.65737, 0.48], [9000000, 1.76781, 0.54], [10000000, 1.89661, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.150153, 0.48], [2000000, 0.341576, 0.48], [3000000, 0.450577, 0.72], [4000000, 0.744338, 0.48], [5000000, 0.860252, 0.6], [6000000, 0.977961, 0.72], [7000000, 1.32962, 0.83], [8000000, 1.69613, 0.48], [9000000, 1.80619, 0.54], [10000000, 1.93996, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.154643, 0.48], [2000000, 0.329187, 0.48], [3000000, 0.433246, 0.72], [4000000, 0.710826, 0.48], [5000000, 0.922001, 0.6], [6000000, 0.931221, 0.72], [7000000, 1.11789, 0.83], [8000000, 1.62199, 0.48], [9000000, 1.72958, 0.54], [10000000, 1.8575, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.120809, 0.95], [2000000, 0.254276, 0.95], [3000000, 0.438993, 0.72], [4000000, 0.570634, 0.95], [5000000, 0.840124, 0.6], [6000000, 1.10553, 0.72], [7000000, 1.24481, 0.83], [8000000, 1.43326, 0.95], [9000000, 1.79115, 0.54], [10000000, 1.91328, 0.6]], "label": "emhash4::HashMap"}], 
"insert_random_full_reserve_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.190733, 0.95], [2000000, 0.444667, 0.93], [3000000, 0.679963, 0.94], [4000000, 1.00987, 0.99], [5000000, 1.23526, 0.98], [6000000, 1.42025, 0.93], [7000000, 1.8376, 0.93], [8000000, 1.98122, 0.98], [9000000, 2.20225, 0.94], [10000000, 2.48676, 0.97]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.071007, 0.48], [2000000, 0.157691, 0.48], [3000000, 0.247617, 0.72], [4000000, 0.39347, 0.48], [5000000, 0.436333, 0.6], [6000000, 0.632375, 0.72], [7000000, 0.718451, 0.83], [8000000, 0.749104, 0.48], [9000000, 0.851869, 0.54], [10000000, 0.961251, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.085162, 0.48], [2000000, 0.188366, 0.48], [3000000, 0.281955, 0.72], [4000000, 0.450426, 0.48], [5000000, 0.602472, 0.6], [6000000, 0.770809, 0.72], [7000000, 0.763218, 0.83], [8000000, 1.21519, 0.48], [9000000, 1.13398, 0.54], [10000000, 1.55798, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.067847, 0.48], [2000000, 0.144602, 0.48], [3000000, 0.289471, 0.72], [4000000, 0.360661, 0.48], [5000000, 0.390004, 0.6], [6000000, 0.597062, 0.72], [7000000, 0.740817, 0.83], [8000000, 0.675715, 0.48], [9000000, 0.763924, 0.54], [10000000, 0.891045, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.074368, 0.48], [2000000, 0.156685, 0.48], [3000000, 0.308849, 0.72], [4000000, 0.393656, 0.48], [5000000, 0.42498, 0.6], [6000000, 0.640859, 0.72], [7000000, 0.997581, 0.42], [8000000, 0.739057, 0.48], [9000000, 0.850621, 0.54], [10000000, 0.982066, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.070486, 0.48], [2000000, 0.154197, 0.48], [3000000, 0.262502, 0.72], [4000000, 0.384214, 0.48], [5000000, 0.498346, 0.6], [6000000, 0.562117, 0.72], [7000000, 0.725177, 0.83], [8000000, 0.784091, 0.48], [9000000, 0.825817, 0.54], [10000000, 0.954516, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.070122, 0.48], [2000000, 0.18256, 0.48], [3000000, 0.266919, 0.72], [4000000, 0.319053, 0.48], [5000000, 0.497734, 0.6], [6000000, 0.55584, 0.72], [7000000, 0.726293, 0.83], [8000000, 0.720323, 0.48], [9000000, 0.82792, 0.54], [10000000, 0.957406, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.069454, 0.48], [2000000, 0.15082, 0.48], [3000000, 0.254828, 0.72], [4000000, 0.321025, 0.48], [5000000, 0.419492, 0.6], [6000000, 0.541667, 0.72], [7000000, 0.696538, 0.83], [8000000, 0.714384, 0.48], [9000000, 0.820219, 0.54], [10000000, 0.94409, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.08293, 0.95], [2000000, 0.189529, 0.95], [3000000, 0.334044, 0.72], [4000000, 0.412505, 0.95], [5000000, 0.474303, 0.6], [6000000, 0.589515, 0.72], [7000000, 0.723711, 0.83], [8000000, 0.998766, 0.95], [9000000, 0.965324, 0.54], [10000000, 1.07777, 0.6]], "label": "emhash4::HashMap"}], 
"read_random_full_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.133495, 0.95], [2000000, 0.287889, 0.93], [3000000, 0.404265, 0.69], [4000000, 0.632196, 0.92], [5000000, 0.676273, 0.57], [6000000, 0.939019, 0.68], [7000000, 1.08282, 0.79], [8000000, 1.34162, 0.9], [9000000, 1.21418, 0.5], [10000000, 1.39285, 0.56]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.030051, 0.48], [2000000, 0.066001, 0.48], [3000000, 0.119287, 0.72], [4000000, 0.186072, 0.48], [5000000, 0.206394, 0.6], [6000000, 0.273652, 0.72], [7000000, 0.384945, 0.83], [8000000, 0.372339, 0.48], [9000000, 0.497307, 0.54], [10000000, 0.486124, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.042217, 0.48], [2000000, 0.094274, 0.48], [3000000, 0.142487, 0.72], [4000000, 0.233694, 0.48], [5000000, 0.291101, 0.6], [6000000, 0.351822, 0.72], [7000000, 0.423531, 0.83], [8000000, 0.594045, 0.48], [9000000, 0.721068, 0.54], [10000000, 0.782651, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.024731, 0.48], [2000000, 0.052773, 0.48], [3000000, 0.112425, 0.72], [4000000, 0.107283, 0.48], [5000000, 0.161121, 0.6], [6000000, 0.231653, 0.72], [7000000, 0.430746, 0.83], [8000000, 0.323206, 0.48], [9000000, 0.369658, 0.54], [10000000, 0.434921, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.031019, 0.48], [2000000, 0.065453, 0.48], [3000000, 0.134664, 0.72], [4000000, 0.134738, 0.48], [5000000, 0.227407, 0.6], [6000000, 0.275095, 0.72], [7000000, 0.245376, 0.42], [8000000, 0.36376, 0.48], [9000000, 0.423692, 0.54], [10000000, 0.496188, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.022811, 0.48], [2000000, 0.047877, 0.48], [3000000, 0.102521, 0.72], [4000000, 0.099253, 0.48], [5000000, 0.133679, 0.6], [6000000, 0.173156, 0.72], [7000000, 0.255694, 0.83], [8000000, 0.270846, 0.48], [9000000, 0.316937, 0.54], [10000000, 0.378506, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.022999, 0.48], [2000000, 0.048588, 0.48], [3000000, 0.084923, 0.72], [4000000, 0.100546, 0.48], [5000000, 0.136435, 0.6], [6000000, 0.178463, 0.72], [7000000, 0.258955, 0.83], [8000000, 0.244437, 0.48], [9000000, 0.306689, 0.54], [10000000, 0.360836, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.022862, 0.48], [2000000, 0.059383, 0.48], [3000000, 0.085732, 0.72], [4000000, 0.130124, 0.48], [5000000, 0.136012, 0.6], [6000000, 0.179109, 0.72], [7000000, 0.260308, 0.83], [8000000, 0.245046, 0.48], [9000000, 0.341557, 0.54], [10000000, 0.381732, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.05288, 0.95], [2000000, 0.119976, 0.95], [3000000, 0.161251, 0.72], [4000000, 0.257806, 0.95], [5000000, 0.261293, 0.6], [6000000, 0.335217, 0.72], [7000000, 0.468922, 0.83], [8000000, 0.59104, 0.95], [9000000, 0.537858, 0.54], [10000000, 0.633646, 0.6]], "label": "emhash4::HashMap"}], 
"delete_random_full_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.341299, 0.0], [2000000, 0.804522, 0.0], [3000000, 1.28382, 0.0], [4000000, 2.11947, 0.0], [5000000, 2.11818, 0.0], [6000000, 2.82491, 0.0], [7000000, 3.06822, 0.0], [8000000, 3.78369, 0.0], [9000000, 4.06273, 0.0], [10000000, 4.60097, 0.0]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.037185, 0.0], [2000000, 0.083928, 0.0], [3000000, 0.18464, 0.0], [4000000, 0.191005, 0.0], [5000000, 0.262466, 0.0], [6000000, 0.356687, 0.0], [7000000, 0.514945, 0.0], [8000000, 0.477111, 0.0], [9000000, 0.591232, 0.0], [10000000, 0.627059, 0.0]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.063593, 0.0], [2000000, 0.165762, 0.0], [3000000, 0.24999, 0.0], [4000000, 0.403816, 0.0], [5000000, 0.458821, 0.0], [6000000, 0.546381, 0.0], [7000000, 0.65673, 0.0], [8000000, 0.929226, 0.0], [9000000, 1.16754, 0.0], [10000000, 1.28731, 0.0]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.043474, 0.0], [2000000, 0.107186, 0.0], [3000000, 0.182278, 0.0], [4000000, 0.19525, 0.0], [5000000, 0.271492, 0.0], [6000000, 0.381875, 0.0], [7000000, 0.608499, 0.0], [8000000, 0.460099, 0.0], [9000000, 0.540477, 0.0], [10000000, 0.634465, 0.0]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.037576, 0.0], [2000000, 0.09121, 0.0], [3000000, 0.156135, 0.0], [4000000, 0.189828, 0.0], [5000000, 0.234953, 0.0], [6000000, 0.365543, 0.0], [7000000, 0.346447, 0.0], [8000000, 0.422676, 0.0], [9000000, 0.463956, 0.0], [10000000, 0.568524, 0.0]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.038118, 0.0], [2000000, 0.070975, 0.0], [3000000, 0.124818, 0.0], [4000000, 0.186389, 0.0], [5000000, 0.212302, 0.0], [6000000, 0.38535, 0.0], [7000000, 0.470258, 0.0], [8000000, 0.420742, 0.0], [9000000, 0.451722, 0.0], [10000000, 0.537358, 0.0]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.044901, 0.0], [2000000, 0.087492, 0.0], [3000000, 0.200248, 0.0], [4000000, 0.18803, 0.0], [5000000, 0.262229, 0.0], [6000000, 0.461652, 0.0], [7000000, 0.585742, 0.0], [8000000, 0.474159, 0.0], [9000000, 0.530049, 0.0], [10000000, 0.638703, 0.0]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.03174, 0.0], [2000000, 0.07065, 0.0], [3000000, 0.124169, 0.0], [4000000, 0.185061, 0.0], [5000000, 0.211207, 0.0], [6000000, 0.383542, 0.0], [7000000, 0.393062, 0.0], [8000000, 0.361156, 0.0], [9000000, 0.448363, 0.0], [10000000, 0.524252, 0.0]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.046821, 0.0], [2000000, 0.107084, 0.0], [3000000, 0.154903, 0.0], [4000000, 0.235289, 0.0], [5000000, 0.254392, 0.0], [6000000, 0.333145, 0.0], [7000000, 0.467377, 0.0], [8000000, 0.562119, 0.0], [9000000, 0.54372, 0.0], [10000000, 0.632414, 0.0]], "label": "emhash4::HashMap"}], 
"iteration_random_full_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.046172, 0.95], [2000000, 0.110844, 0.93], [3000000, 0.181825, 0.69], [4000000, 0.263726, 0.92], [5000000, 0.334453, 0.57], [6000000, 0.39109, 0.68], [7000000, 0.651327, 0.79], [8000000, 0.519533, 0.9], [9000000, 0.652985, 0.5], [10000000, 0.704402, 0.56]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.006568, 0.48], [2000000, 0.013047, 0.48], [3000000, 0.016668, 0.72], [4000000, 0.024732, 0.48], [5000000, 0.02824, 0.6], [6000000, 0.032415, 0.72], [7000000, 0.03719, 0.83], [8000000, 0.047796, 0.48], [9000000, 0.071583, 0.54], [10000000, 0.056143, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.008473, 0.48], [2000000, 0.017012, 0.48], [3000000, 0.016189, 0.72], [4000000, 0.033791, 0.48], [5000000, 0.034409, 0.6], [6000000, 0.031827, 0.72], [7000000, 0.026748, 0.83], [8000000, 0.067399, 0.48], [9000000, 0.068582, 0.54], [10000000, 0.069184, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.012657, 0.48], [2000000, 0.025099, 0.48], [3000000, 0.021031, 0.72], [4000000, 0.050029, 0.48], [5000000, 0.047654, 0.6], [6000000, 0.041702, 0.72], [7000000, 0.036028, 0.83], [8000000, 0.100492, 0.48], [9000000, 0.098749, 0.54], [10000000, 0.096138, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.012224, 0.48], [2000000, 0.024505, 0.48], [3000000, 0.020355, 0.72], [4000000, 0.048946, 0.48], [5000000, 0.046085, 0.6], [6000000, 0.040001, 0.72], [7000000, 0.096338, 0.42], [8000000, 0.097751, 0.48], [9000000, 0.095441, 0.54], [10000000, 0.091739, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.013599, 0.48], [2000000, 0.02769, 0.48], [3000000, 0.022487, 0.72], [4000000, 0.054413, 0.48], [5000000, 0.051711, 0.6], [6000000, 0.044843, 0.72], [7000000, 0.037062, 0.83], [8000000, 0.110213, 0.48], [9000000, 0.107707, 0.54], [10000000, 0.103003, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.013618, 0.48], [2000000, 0.028051, 0.48], [3000000, 0.022374, 0.72], [4000000, 0.055777, 0.48], [5000000, 0.051219, 0.6], [6000000, 0.045369, 0.72], [7000000, 0.036875, 0.83], [8000000, 0.11164, 0.48], [9000000, 0.10852, 0.54], [10000000, 0.105126, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.013661, 0.48], [2000000, 0.027168, 0.48], [3000000, 0.022499, 0.72], [4000000, 0.054364, 0.48], [5000000, 0.051714, 0.6], [6000000, 0.044739, 0.72], [7000000, 0.037625, 0.83], [8000000, 0.11029, 0.48], [9000000, 0.108597, 0.54], [10000000, 0.104324, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.006239, 0.95], [2000000, 0.012535, 0.95], [3000000, 0.020677, 0.72], [4000000, 0.02478, 0.95], [5000000, 0.035721, 0.6], [6000000, 0.040564, 0.72], [7000000, 0.045311, 0.83], [8000000, 0.049499, 0.95], [9000000, 0.066988, 0.54], [10000000, 0.070256, 0.6]], "label": "emhash4::HashMap"}], 
"insert_random_full_memory": [{"program": "std_unordered_map", "data": [[1000000, 40644608, 0.95], [2000000, 81317888, 0.93], [3000000, 131215360, 0.69], [4000000, 162942976, 0.92], [5000000, 230957056, 0.57], [6000000, 263049216, 0.68], [7000000, 294948864, 0.79], [8000000, 326840320, 0.9], [9000000, 432136192, 0.5], [10000000, 463908864, 0.56]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 36208640, 0.48], [2000000, 71831552, 0.48], [3000000, 71602176, 0.72], [4000000, 143097856, 0.48], [5000000, 143028224, 0.6], [6000000, 143020032, 0.72], [7000000, 143159296, 0.83], [8000000, 285593600, 0.48], [9000000, 285802496, 0.54], [10000000, 285802496, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 36204544, 0.48], [2000000, 71626752, 0.48], [3000000, 71655424, 0.72], [4000000, 142934016, 0.48], [5000000, 142962688, 0.6], [6000000, 143261696, 0.72], [7000000, 143134720, 0.83], [8000000, 285548544, 0.48], [9000000, 285700096, 0.54], [10000000, 285642752, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 50896896, 0.48], [2000000, 101113856, 0.48], [3000000, 101134336, 0.72], [4000000, 201568256, 0.48], [5000000, 201723904, 0.6], [6000000, 201777152, 0.72], [7000000, 201736192, 0.83], [8000000, 402968576, 0.48], [9000000, 403189760, 0.54], [10000000, 403107840, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 50868224, 0.48], [2000000, 101056512, 0.48], [3000000, 100954112, 0.72], [4000000, 201715712, 0.48], [5000000, 201674752, 0.6], [6000000, 201658368, 0.72], [7000000, 402944000, 0.42], [8000000, 403025920, 0.48], [9000000, 403238912, 0.54], [10000000, 403173376, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 50827264, 0.48], [2000000, 101027840, 0.48], [3000000, 101023744, 0.72], [4000000, 201777152, 0.48], [5000000, 201658368, 0.6], [6000000, 201777152, 0.72], [7000000, 201748480, 0.83], [8000000, 403116032, 0.48], [9000000, 403075072, 0.54], [10000000, 403218432, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 50819072, 0.48], [2000000, 101167104, 0.48], [3000000, 101072896, 0.72], [4000000, 201785344, 0.48], [5000000, 201547776, 0.6], [6000000, 201891840, 0.72], [7000000, 201809920, 0.83], [8000000, 403169280, 0.48], [9000000, 403185664, 0.54], [10000000, 403173376, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 50888704, 0.48], [2000000, 101048320, 0.48], [3000000, 101011456, 0.72], [4000000, 201785344, 0.48], [5000000, 201613312, 0.6], [6000000, 201842688, 0.72], [7000000, 201744384, 0.83], [8000000, 402784256, 0.48], [9000000, 403075072, 0.54], [10000000, 403234816, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 25845760, 0.95], [2000000, 50987008, 0.95], [3000000, 101724160, 0.72], [4000000, 101634048, 0.95], [5000000, 202661888, 0.6], [6000000, 202706944, 0.72], [7000000, 202919936, 0.83], [8000000, 202756096, 0.95], [9000000, 405164032, 0.54], [10000000, 405331968, 0.6]], "label": "emhash4::HashMap"}], 
"read_miss_random_full_runtime": [{"program": "std_unordered_map", "data": [[1000000, 0.165389, 0.95], [2000000, 0.363835, 0.93], [3000000, 0.490514, 0.69], [4000000, 0.793867, 0.92], [5000000, 0.723376, 0.57], [6000000, 1.01643, 0.68], [7000000, 1.30008, 0.79], [8000000, 1.66875, 0.9], [9000000, 1.35376, 0.5], [10000000, 1.65732, 0.56]], "label": "std::unordered_map"}, {"program": "hood_map", "data": [[1000000, 0.012643, 0.48], [2000000, 0.025925, 0.48], [3000000, 0.060478, 0.72], [4000000, 0.057012, 0.48], [5000000, 0.091537, 0.6], [6000000, 0.13633, 0.72], [7000000, 0.249189, 0.83], [8000000, 0.213669, 0.48], [9000000, 0.267778, 0.54], [10000000, 0.319474, 0.6]], "label": "robin_hood::flat_map"}, {"program": "phmap_map", "data": [[1000000, 0.016957, 0.48], [2000000, 0.035521, 0.48], [3000000, 0.067548, 0.72], [4000000, 0.085178, 0.48], [5000000, 0.112984, 0.6], [6000000, 0.162939, 0.72], [7000000, 0.278395, 0.83], [8000000, 0.328197, 0.48], [9000000, 0.352693, 0.54], [10000000, 0.363948, 0.6]], "label": "phmap_map"}, {"program": "tsl_robin_map", "data": [[1000000, 0.026086, 0.48], [2000000, 0.055222, 0.48], [3000000, 0.112489, 0.72], [4000000, 0.115914, 0.48], [5000000, 0.167241, 0.6], [6000000, 0.235509, 0.72], [7000000, 0.446319, 0.83], [8000000, 0.303854, 0.48], [9000000, 0.364636, 0.54], [10000000, 0.448295, 0.6]], "label": "tsl::robin_map"}, {"program": "ska_flat_hash_map", "data": [[1000000, 0.035105, 0.48], [2000000, 0.074202, 0.48], [3000000, 0.139467, 0.72], [4000000, 0.154368, 0.48], [5000000, 0.21418, 0.6], [6000000, 0.293643, 0.72], [7000000, 0.327993, 0.42], [8000000, 0.382647, 0.48], [9000000, 0.426757, 0.54], [10000000, 0.545075, 0.6]], "label": "ska::flat_hash_map"}, {"program": "emhash_hash_map", "data": [[1000000, 0.024559, 0.48], [2000000, 0.052242, 0.48], [3000000, 0.08809, 0.72], [4000000, 0.146548, 0.48], [5000000, 0.147959, 0.6], [6000000, 0.182368, 0.72], [7000000, 0.283939, 0.83], [8000000, 0.280303, 0.48], [9000000, 0.329725, 0.54], [10000000, 0.385002, 0.6]], "label": "emhash5::HashMap"}, {"program": "emhash_hash_map2", "data": [[1000000, 0.024685, 0.48], [2000000, 0.067694, 0.48], [3000000, 0.088559, 0.72], [4000000, 0.109992, 0.48], [5000000, 0.191235, 0.6], [6000000, 0.183706, 0.72], [7000000, 0.288084, 0.83], [8000000, 0.282832, 0.48], [9000000, 0.331663, 0.54], [10000000, 0.387985, 0.6]], "label": "emhash7::HashMap"}, {"program": "emhash_hash_map3", "data": [[1000000, 0.024823, 0.48], [2000000, 0.067836, 0.48], [3000000, 0.08881, 0.72], [4000000, 0.146931, 0.48], [5000000, 0.192745, 0.6], [6000000, 0.185602, 0.72], [7000000, 0.288598, 0.83], [8000000, 0.282842, 0.48], [9000000, 0.333211, 0.54], [10000000, 0.418288, 0.6]], "label": "emhash2::HashMap"}, {"program": "emhash_hash_map4", "data": [[1000000, 0.049925, 0.95], [2000000, 0.111944, 0.95], [3000000, 0.155615, 0.72], [4000000, 0.238457, 0.95], [5000000, 0.302209, 0.6], [6000000, 0.401037, 0.72], [7000000, 0.459652, 0.83], [8000000, 0.529049, 0.95], [9000000, 0.514097, 0.54], [10000000, 0.623958, 0.6]], "label": "emhash4::HashMap"}]};

programs = {
 "std_unordered_map": "std::unordered_map", 
 "hood_map": "robin_hood::flat_map", 
 "hrd_hash_map": "hrd7::hash_map", 
 "tsl_hopscotch_map": "tsl::hopscotch_map", 
 "phmap_map": "phmap_map", 
 "dense_hash_map": "google:dense_hash_map", 
 "tsl_robin_map": "tsl::robin_map", 
 "tsl_hopscotch_map_store_hash": "tsl::hopscotch_map (with StoreHash)", 
 "tsl_robin_map_store_hash": "tsl::robin_map (with StoreHash)", 
 "tsl_hopscotch_map_mlf_0_5": "tsl::hopscotch_map (0.5 mlf)", 
 "tsl_robin_map_mlf_0_9": "tsl::robin_map (0.9 mlf)", 
 "tsl_ordered_map": "tsl::ordered_map", 
 "tsl_robin_pg_map": "tsl::robin_pg_map", 
 "ska_flat_hash_map": "ska::flat_hash_map", 
 "ska_flat_hash_map_power_of_two": "ska::flat_hash_map (power of two)", 
 "boost_unordered_map": "boost::unordered_map", 
 "emhash_hash_map": "emhash5::HashMap", 
 "emhash_hash_map2": "emhash7::HashMap", 
 "emhash_hash_map3": "emhash2::HashMap", 
 "emhash_hash_map4": "emhash4::HashMap", 
 "tsl_sparse_map": "tsl::sparse_map", 
 "tsl_array_map": "tsl::array_map", 
 "tsl_array_map_mlf_1_0": "tsl::array_map (1.0 mlf)"
};

default_programs_show = ['std_unordered_map', 'dense_hash_map', 'hrd_hash_map', 'emhash_hash_map', 'emhash_hash_map2', 'emhash_hash_map3', 'emhash_hash_map4', 'ska_flat_hash_map', 'hood_map', 'phmap_map', 'tsl_robin_map'];


    function plot_chart(dataset, chart_container, choices_container, chart_settings, redraw_only = false) {
        if(!redraw_only) {
            // Set colors
            var color = 0;
            $.each(dataset, function(key, val) {
                val.color = color;
                color++;
            });
            
            // Insert checkboxes 
            $.each(dataset, function(key, val) {
                checked = '';
                if(default_programs_show.indexOf(val.program) > -1) {
                    checked = 'checked';
                }
                
                $(choices_container).append(
                    "<li><input type='checkbox' value='" + key +"' name='" + val.program + "' " + checked + "></input>" +
                    "<label for='id" + key + "'>" + val.label + "</label></li>");
            });
            
            $(choices_container).find("input").change(plot_according_to_choices);
        }
        
        function plot_according_to_choices() {
            var data = [];
            $(choices_container).find("input:checked").each(
                function () {
                    var key = $(this).attr("value");
                    if (key && dataset[key]) {
                        data.push(dataset[key]);
                    }
                }
            );

            $.plot(chart_container, data, chart_settings);
            

            $(chart_container).bind("plothover", function (event, pos, item) {
                if (item) {
                    var x = item.datapoint[0];
                    var y = item.datapoint[1].toFixed(4) + "s";
                    if(chart_settings == memory_settings) {
                        y = (item.datapoint[1]/1024/1024).toFixed(2) + " MiB";
                    }

                    var load_factor = item.series.data[item.dataIndex][2]
                    if(load_factor == 0.0) {
                        load_factor = "unknown"
                    }
                    
                    $("#tooltip").html("" + y + " ; " + x + 
                                        "<br\>" + load_factor + " load factor" +
                                        "<br\>" + item.series.label)
                                    .css({top: item.pageY+5, left: item.pageX+5})
                                    .fadeIn(200);
                } else {
                    $("#tooltip").hide();
                }        
            });
        }

        plot_according_to_choices();
    }
    
    
    function plot_all_charts(redraw_only = false) {
        plot_chart(chart_data['insert_random_shuffle_range_runtime'], '#insert_random_shuffle_range_runtime', '#insert_random_shuffle_range_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_random_shuffle_range_runtime'], '#read_random_shuffle_range_runtime', '#read_random_shuffle_range_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['insert_random_full_runtime'], '#insert_random_full_runtime', '#insert_random_full_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['insert_random_full_reserve_runtime'], '#insert_random_full_reserve_runtime', '#insert_random_full_reserve_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_random_full_runtime'], '#read_random_full_runtime', '#read_random_full_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_miss_random_full_runtime'], '#read_miss_random_full_runtime', '#read_miss_random_full_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_random_full_after_delete_runtime'], '#read_random_full_after_delete_runtime', '#read_random_full_after_delete_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['iteration_random_full_runtime'], '#iteration_random_full_runtime', '#iteration_random_full_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['delete_random_full_runtime'], '#delete_random_full_runtime', '#delete_random_full_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['insert_random_full_memory'], '#insert_random_full_memory', '#insert_random_full_memory_choices', memory_settings, redraw_only);
        plot_chart(chart_data['insert_random_full_reserve_memory'], '#insert_random_full_reserve_memory', '#insert_random_full_reserve_memory_choices', memory_settings, redraw_only);
        
        plot_chart(chart_data['insert_small_string_runtime'], '#insert_small_string_runtime', '#insert_small_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['insert_small_string_reserve_runtime'], '#insert_small_string_reserve_runtime', '#insert_small_string_reserve_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_small_string_runtime'], '#read_small_string_runtime', '#read_small_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_miss_small_string_runtime'], '#read_miss_small_string_runtime', '#read_miss_small_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_small_string_after_delete_runtime'], '#read_small_string_after_delete_runtime', '#read_small_string_after_delete_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['delete_small_string_runtime'], '#delete_small_string_runtime', '#delete_small_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['insert_small_string_memory'], '#insert_small_string_memory', '#insert_small_string_memory_choices', memory_settings, redraw_only);
        plot_chart(chart_data['insert_small_string_reserve_memory'], '#insert_small_string_reserve_memory', '#insert_small_string_reserve_memory_choices', memory_settings, redraw_only);

        plot_chart(chart_data['insert_string_runtime'], '#insert_string_runtime', '#insert_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['insert_string_reserve_runtime'], '#insert_string_reserve_runtime', '#insert_string_reserve_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_string_runtime'], '#read_string_runtime', '#read_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_miss_string_runtime'], '#read_miss_string_runtime', '#read_miss_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['read_string_after_delete_runtime'], '#read_string_after_delete_runtime', '#read_string_after_delete_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['delete_string_runtime'], '#delete_string_runtime', '#delete_string_runtime_choices', runtime_settings, redraw_only);
        plot_chart(chart_data['insert_string_memory'], '#insert_string_memory', '#insert_string_memory_choices', memory_settings, redraw_only);
        plot_chart(chart_data['insert_string_reserve_memory'], '#insert_string_reserve_memory', '#insert_string_reserve_memory_choices', memory_settings, redraw_only);
    }

    $(function () {
        // Set global choices boxes
        var i = 0;
        for(var program in programs) {
            checked = '';
            if(default_programs_show.indexOf(program) > -1) {
                checked = 'checked';
            }
            
            $("#global_choices").append("<li><input type='checkbox' id='global_choice_" + i + "' " + 
                                        checked + "></input>" + programs[program] + "</li>");
            $("#global_choice_" + i).change({name: program}, function(event) {
                $("input[name='" + event.data.name + "']").prop('checked', this.checked).change();
            });
            i++;
        }
        
        // Set select all link
        $("#global_select_all_none").append("<a href='javascript:void(0);' id='global_select_all'>all</a> ");
        $("#global_select_all").click(function() {
            $("input").prop('checked', true);
            plot_all_charts(true);
        });

        // Set select none link
        $("#global_select_all_none").append(" <a href='javascript:void(0);' id='global_select_none'>none</a>");
        $("#global_select_none").click(function() {
            $("input").prop('checked', false);
            plot_all_charts(true);
        });
        
        // Draw charts
        plot_all_charts();
    });
    
</script>

<style>
    div.global {
        margin: auto;
        width: 800px;
    }
    div.global_select_all_none {
        text-align: center;
    }
    div.chart {
        width: 750px;
        height: 500px;
    }
    div.xaxis-title {
        width: 750px;
        text-align: center;
        font-style: italic;
        font-size: small;
        color: #666;
    }
    .choices li {
        margin-left: 5%;
        display: inline-block;
        width: 45%;
    }
</style>


<div class="global">

<h2>Global selection</h2>
<ul class="choices" id="global_choices"></ul>
<div class="global_select_all_none" id="global_select_all_none"></div>

<h2>Integers</h2>

<p>For the integers tests, we use hash maps with int64_t as key and int64_t as value.</p>



<h3>Random shuffle inserts: execution time (integers)</h3>

<p>Before the test, we generate a vector with the values [0, nb_entries) and shuffle this vector. 
Then for each value k in the vector, we insert the key-value pair (k, 1) in the hash map.</p>

<div class="chart" id="insert_random_shuffle_range_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_random_shuffle_range_runtime_choices"></ul>


<h3>Random full inserts: execution time (integers)</h3>

<p>Before the test, we generate a vector of nb_entries size where each value is randomly taken from an uniform random number generator from all possible positive values an int64_t can hold. 
Then for each value k in the vector, we insert the key-value pair (k, 1) in the hash map.</p>

<div class="chart" id="insert_random_full_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_random_full_runtime_choices"></ul>


<h3>Random full inserts with reserve: execution time (integers)</h3>

<p>Same as the random full inserts test but the reserve method of the hash map is called beforehand to avoid any rehash during the insertion. 
It provides a fair comparison even if the growth factor of each hash map is different.</p>

<div class="chart" id="insert_random_full_reserve_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_random_full_reserve_runtime_choices"></ul>


<h3>Random full deletes: execution time (integers)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the random full insert test. 
We then delete each key one by one in a different and random order than the one they were inserted.</p>

<div class="chart" id="delete_random_full_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="delete_random_full_runtime_choices"></ul>


<h3>Random shuffle reads: execution time (integers)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the random shuffle inserts test. 
We then read each key-value pair in a different and random order than the one they were inserted.</p>

<div class="chart" id="read_random_shuffle_range_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_random_shuffle_range_runtime_choices"></ul>


<h3>Random full reads: execution time (integers)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the random full inserts test. 
We then read each key-value pair in a different and random order than the one they were inserted.</p>

<div class="chart" id="read_random_full_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_random_full_runtime_choices"></ul>

<h3>Random full reads misses: execution time (integers)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the random full inserts test. 
We then generate another vector of nb_entries random elements different from the inserted elements and 
we try to search for these unknown elements in the hash map.</p>

<div class="chart" id="read_miss_random_full_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_miss_random_full_runtime_choices"></ul>


<h3>Random full reads after deleting half: execution time (integers)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the random full inserts test 
before deleting half of these values randomly. We then try to read all the original values in a 
different order which will lead to 50% hits and 50% misses.</p>

<div class="chart" id="read_random_full_after_delete_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_random_full_after_delete_runtime_choices"></ul>



<h3>Random full iteration: execution time (integers)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the random full inserts test. 
We then use the hash map iterators to read all the key-value pairs.</p>

<div class="chart" id="iteration_random_full_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="iteration_random_full_runtime_choices"></ul>



<h3>Memory usage of random full inserts (integers)</h3>

<p>Before the random full inserts benchmark finishes, we measure the memory that the hash map is using.</p>

<div class="chart" id="insert_random_full_memory"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_random_full_memory_choices"></ul>


<h3>Memory usage of random full inserts with reserve (integers)</h3>

<p>Before the random full inserts with reserve benchmark finishes, we measure the memory that the hash map is using. 
The benchmark is similar to the one above but without measuring the memory fragmentation that the rehash process
may cause.</p>

<div class="chart" id="insert_random_full_reserve_memory"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_random_full_reserve_memory_choices"></ul>









<h2>Small strings</h2>
<p>For the small string tests, we use hash maps with std::string as key and int64_t as value.</p>

<p>Each string is a random generated string of 15 alphanumeric characters (+1 for the null terminator). A generated key may look like "ju1AOoeWT3LdJxL".<p>

<h3>Inserts: execution time (small strings)</h3>

<p>For each entry in the range [0, nb_entries), we generate a string as key and insert it with the value 1.</p>

<div class="chart" id="insert_small_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_small_string_runtime_choices"></ul>


<h3>Inserts with reserve: execution time (small strings)</h3>

<p>Same as the inserts test but the reserve method of the hash map is called beforehand to avoid any rehash during the insertion. 
It provides a fair comparison even if the growth factor of each hash map is different.</p>

<div class="chart" id="insert_small_string_reserve_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_small_string_reserve_runtime_choices"></ul>


<h3>Deletes: execution time (small strings)</h3>

<p>Before the test, we insert nb_entries elements in the hash map as in the inserts test. 
We then delete each key one by one in a different and random order than the one they were inserted.</p>

<div class="chart" id="delete_small_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="delete_small_string_runtime_choices"></ul>


<h3>Reads: execution time (small strings)</h3>

<p>Before the test, we insert nb_entries elements in the hash map as in the inserts test. 
We then read each key-value pair in a different and random order than the one they were inserted.</p>

<div class="chart" id="read_small_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_small_string_runtime_choices"></ul>


<h3>Reads misses: execution time (small strings)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the inserts test. 
We then generate nb_entries strings different from the inserted elements and 
we try to search for these unknown elements in the hash map.</p>

<div class="chart" id="read_miss_small_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_miss_small_string_runtime_choices"></ul>


<h3>Reads after deleting half: execution time (small strings)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the inserts test before 
deleting half of these values randomly. We then try to read all the original values in a 
different order which will lead to 50% hits and 50% misses.</p>

<div class="chart" id="read_small_string_after_delete_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_small_string_after_delete_runtime_choices"></ul>


<h3>Memory usage of inserts (small strings)</h3>

<p>Before the inserts benchmark finishes, we measure the memory that the hash map is using.</p>

<div class="chart" id="insert_small_string_memory"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_small_string_memory_choices"></ul>


<h3>Memory usage of inserts with reserve (small strings)</h3>

<p>Before the inserts with reserve benchmark finishes, we measure the memory that the hash map is using.
The benchmark is similar to the one above but without measuring the memory fragmentation that the rehash process
may cause.</p>

<div class="chart" id="insert_small_string_reserve_memory"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_small_string_reserve_memory_choices"></ul>





<h2>Strings</h2>
<p>For the string tests, we use hash maps with std::string as key and int64_t as value.</p>

<p>Each string is a random generated string of 50 alphanumeric characters (+1 for the null terminator). A generated key may look like "nv46iTRp7ur6UMbdgEkCHpoq7Qx7UU9Ta0u1ETdAvUb4LG6Xu6".<p>

<h3>Inserts: execution time (strings)</h3>

<p>For each entry in the range [0, nb_entries), we generate a string as key and insert it with the value 1.</p>

<div class="chart" id="insert_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_string_runtime_choices"></ul>


<h3>Inserts with reserve: execution time (strings)</h3>

<p>Same as the inserts test but the reserve method of the hash map is called beforehand to avoid any rehash during the insertion. 
It provides a fair comparison even if the growth factor of each hash map is different.</p>

<div class="chart" id="insert_string_reserve_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_string_reserve_runtime_choices"></ul>


<h3>Deletes: execution time (strings)</h3>

<p>Before the test, we insert nb_entries elements in the hash map as in the inserts test. 
We then delete each key one by one in a different and random order than the one they were inserted.</p>

<div class="chart" id="delete_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="delete_string_runtime_choices"></ul>


<h3>Reads: execution time (strings)</h3>

<p>Before the test, we insert nb_entries elements in the hash map as in the inserts test. 
We then read each key-value pair in a different and random order than the one they were inserted.</p>

<div class="chart" id="read_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_string_runtime_choices"></ul>


<h3>Reads misses: execution time (strings)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the inserts test. 
We then generate nb_entries strings different from the inserted elements and 
we try to search for these unknown elements in the hash map.</p>

<div class="chart" id="read_miss_string_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_miss_string_runtime_choices"></ul>


<h3>Reads after deleting half: execution time (strings)</h3>

<p>Before the test, we insert nb_entries elements in the same way as in the inserts test before deleting half of these values randomly. 
We then try to read all the original values in a different order which will lead to 50% hits and 50% misses.</p>

<div class="chart" id="read_string_after_delete_runtime"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="read_string_after_delete_runtime_choices"></ul>


<h3>Memory usage of inserts (strings)</h3>

<p>Before the inserts benchmark finishes, we measure the memory that the hash map is using.</p>

<div class="chart" id="insert_string_memory"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_string_memory_choices"></ul>


<h3>Memory usage of inserts with reserve (strings)</h3>

<p>Before the inserts with reserve benchmark finishes, we measure the memory that the hash map is using.
The benchmark is similar to the one above but without measuring the memory fragmentation that the rehash process
may cause.</p>

<div class="chart" id="insert_string_reserve_memory"></div>
<div class="xaxis-title">number of entries in hash table</div>
<ul class="choices" id="insert_string_reserve_memory_choices"></ul>

</div>

</body>
</html>
